package CSDN顺序存储;

public class SqList {
    static final int DEFAULT_SIZE = 10;
    private Object array[];
    private int capacity;//顺序表的容量
    private int length;//顺序表的当前长度

    //    构造方法 初始化线性表
    public SqList() {
        this(DEFAULT_SIZE);//调用构造方法
    }

    public SqList(int capacity) {
        array = new Object[capacity];
        this.capacity = capacity;
        this.length = 0;
    }

    //    销毁顺序表
    public void destroy() {
        array = null;
        capacity = 0;
        length = 0;
    }

    //    将顺序表置空
    public void clear() {
        for (int i = 0; i < length; i++) {
            array[i] = null;
        }
        length = 0;
    }

    //    判断顺序表是否为空
    public boolean isEmpty() {
        return length == 0;
    }

    //    返回顺序表中元素的个数
    public int getLength() {
        return length;
    }

    //    返回线性表中的第i个元素
    public Object getElement(int i) throws Exception {
        if (i < 0 || i >= length) {
            throw new Exception("要获取的元素下标已越界");
        } else {
            return array[i];
        }
    }

    //元素判定方法，返回顺序表中第一个与elem 相等的元素的下标.若不存在则返回-1
    public int getLocate(Object object) {
        int locate = 0;
        while (locate <= length && !array[locate].equals(object)) {
            locate++;
        }
        if (locate >= length) {
            locate = -1;
        }
        return locate;
    }

    // 若object是数据表中的元素，且不是第一个，则返回它的前驱，否则返回空
    public Object priorElem(Object object) {
        int index = getLocate(object);
        if (index > 0 && index < length) {
            return array[index - 1];
        } else {
            return null;
        }
    }

    //    若object是数据表中的元素，且不是最后一个，则返回它的后继，否则返回空
    public Object nextElem(Object object) {
        int index = getLocate(object);
        if (index >= 0 && index < length - 1) {
            return array[index + 1];
        } else {
            return null;
        }
    }

    //在表中第index个位置之前插入新元素object，顺序表的长度加一
    public void listInsert(int index, Object object) throws Exception {
        if (index < 0) {
            throw new Exception("插入元素的下标越界插入失败");
        } else if (length+1 >capacity) {
            throw new Exception("顺序表已满，插入失败");
        } else if (index >= length) {
            index = length;
        }
        //将下标为index到length-1的元素全部后移一位
        for (int i = length - 1; i >= index-1; i--) {
            array[i + 1] = array[i];
        }
        array[index-1] = object;
        length++;
    }

    //删除指定位置index前一个元素
    public void listDelete(int index) throws Exception {
        if (index <= 0 || index > length) {
            throw new Exception("要删除元素的下标越界删除失败");
        }
        //将下标为index到length-1的元素全部前移一位
        for (int i = index - 1; i <length-1 ; i++) {
            array[i] = array[i+1];
        }
        array[length-1]=null;
        length--;
    }

    //    打印整个顺序表
    public void display() {
        for (int i = 0; i < length; i++) {
            System.out.println(array[i] + "  ");
        }
    }

    //   添加元素
    public void add(Object object) throws Exception {
        if (capacity > length) {
            array[length] = object;
            length++;
        } else {
            throw new Exception("顺序表已满");
        }
    }
}
